home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 10868 / 10868.xpi / modules / resource.js < prev    next >
Encoding:
Text File  |  2010-02-02  |  11.8 KB  |  368 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is Bookmarks Sync.
  15.  *
  16.  * The Initial Developer of the Original Code is Mozilla.
  17.  * Portions created by the Initial Developer are Copyright (C) 2007
  18.  * the Initial Developer. All Rights Reserved.
  19.  *
  20.  * Contributor(s):
  21.  *  Dan Mills <thunder@mozilla.com>
  22.  *  Anant Narayanan <anant@kix.in>
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37.  
  38. const EXPORTED_SYMBOLS = ["Resource"];
  39.  
  40. const Cc = Components.classes;
  41. const Ci = Components.interfaces;
  42. const Cr = Components.results;
  43. const Cu = Components.utils;
  44.  
  45. Cu.import("resource://weave/ext/Observers.js");
  46. Cu.import("resource://weave/ext/Preferences.js");
  47. Cu.import("resource://weave/ext/Sync.js");
  48. Cu.import("resource://weave/log4moz.js");
  49. Cu.import("resource://weave/constants.js");
  50. Cu.import("resource://weave/util.js");
  51. Cu.import("resource://weave/auth.js");
  52.  
  53. // = Resource =
  54. //
  55. // Represents a remote network resource, identified by a URI.
  56. function Resource(uri) {
  57.   this._init(uri);
  58. }
  59. Resource.prototype = {
  60.   _logName: "Net.Resource",
  61.  
  62.   // ** {{{ Resource.authenticator }}} **
  63.   //
  64.   // Getter and setter for the authenticator module
  65.   // responsible for this particular resource. The authenticator
  66.   // module may modify the headers to perform authentication
  67.   // while performing a request for the resource, for example.
  68.   get authenticator() {
  69.     if (this._authenticator)
  70.       return this._authenticator;
  71.     else
  72.       return Auth.lookupAuthenticator(this.spec);
  73.   },
  74.   set authenticator(value) {
  75.     this._authenticator = value;
  76.   },
  77.  
  78.   // ** {{{ Resource.headers }}} **
  79.   //
  80.   // Getter for access to received headers after the request
  81.   // for the resource has been made, setter for headers to be included
  82.   // while making a request for the resource.
  83.   get headers() {
  84.     return this.authenticator.onRequest(this._headers);
  85.   },
  86.   set headers(value) {
  87.     this._headers = value;
  88.   },
  89.   setHeader: function Res_setHeader() {
  90.     if (arguments.length % 2)
  91.       throw "setHeader only accepts arguments in multiples of 2";
  92.     for (let i = 0; i < arguments.length; i += 2) {
  93.       this._headers[arguments[i]] = arguments[i + 1];
  94.     }
  95.   },
  96.  
  97.   // ** {{{ Resource.uri }}} **
  98.   //
  99.   // URI representing this resource.
  100.   get uri() {
  101.     return this._uri;
  102.   },
  103.   set uri(value) {
  104.     if (typeof value == 'string')
  105.       this._uri = Utils.makeURI(value);
  106.     else
  107.       this._uri = value;
  108.   },
  109.  
  110.   // ** {{{ Resource.spec }}} **
  111.   //
  112.   // Get the string representation of the URI.
  113.   get spec() {
  114.     if (this._uri)
  115.       return this._uri.spec;
  116.     return null;
  117.   },
  118.  
  119.   // ** {{{ Resource.data }}} **
  120.   //
  121.   // Get and set the data encapulated in the resource.
  122.   _data: null,
  123.   get data() this._data,
  124.   set data(value) {
  125.     this._data = value;
  126.   },
  127.  
  128.   _init: function Res__init(uri) {
  129.     this._log = Log4Moz.repository.getLogger(this._logName);
  130.     this._log.level =
  131.       Log4Moz.Level[Utils.prefs.getCharPref("log.logger.network.resources")];
  132.     this.uri = uri;
  133.     this._headers = {'Content-type': 'text/plain'};
  134.   },
  135.  
  136.   // ** {{{ Resource._createRequest }}} **
  137.   //
  138.   // This method returns a new IO Channel for requests to be made
  139.   // through. It is never called directly, only {{{_request}}} uses it
  140.   // to obtain a request channel.
  141.   //
  142.   _createRequest: function Res__createRequest() {
  143.     let channel = Svc.IO.newChannel(this.spec, null, null).
  144.       QueryInterface(Ci.nsIRequest).QueryInterface(Ci.nsIHttpChannel);
  145.  
  146.     // Always validate the cache:
  147.     channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE;
  148.     channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING;
  149.  
  150.     // Setup a callback to handle bad HTTPS certificates.
  151.     channel.notificationCallbacks = new badCertListener();
  152.  
  153.     // Avoid calling the authorizer more than once
  154.     let headers = this.headers;
  155.     for (let key in headers) {
  156.       if (key == 'Authorization')
  157.         this._log.trace("HTTP Header " + key + ": ***** (suppressed)");
  158.       else
  159.         this._log.trace("HTTP Header " + key + ": " + headers[key]);
  160.       channel.setRequestHeader(key, headers[key], false);
  161.     }
  162.     return channel;
  163.   },
  164.  
  165.   _onProgress: function Res__onProgress(channel) {},
  166.  
  167.   // ** {{{ Resource._request }}} **
  168.   //
  169.   // Perform a particular HTTP request on the resource. This method
  170.   // is never called directly, but is used by the high-level
  171.   // {{{get}}}, {{{put}}}, {{{post}}} and {{delete}} methods.
  172.   _request: function Res__request(action, data) {
  173.     let iter = 0;
  174.     let channel = this._createRequest();
  175.  
  176.     if ("undefined" != typeof(data))
  177.       this._data = data;
  178.  
  179.     // PUT and POST are trreated differently because
  180.     // they have payload data.
  181.     if ("PUT" == action || "POST" == action) {
  182.       // Convert non-string bodies into JSON
  183.       if (this._data.constructor.toString() != String)
  184.         this._data = JSON.stringify(this._data);
  185.  
  186.       this._log.debug(action + " Length: " + this._data.length);
  187.       this._log.trace(action + " Body: " + this._data);
  188.  
  189.       let type = ('Content-Type' in this._headers)?
  190.         this._headers['Content-Type'] : 'text/plain';
  191.  
  192.       let stream = Cc["@mozilla.org/io/string-input-stream;1"].
  193.         createInstance(Ci.nsIStringInputStream);
  194.       stream.setData(this._data, this._data.length);
  195.  
  196.       channel.QueryInterface(Ci.nsIUploadChannel);
  197.       channel.setUploadStream(stream, type, this._data.length);
  198.     }
  199.  
  200.     // Setup a channel listener so that the actual network operation
  201.     // is performed asynchronously.
  202.     let [chanOpen, chanCb] = Sync.withCb(channel.asyncOpen, channel);
  203.     let listener = new ChannelListener(chanCb, this._onProgress, this._log);
  204.     channel.requestMethod = action;
  205.  
  206.     // The channel listener might get a failure code
  207.     try {
  208.       this._data = chanOpen(listener, null);
  209.     }
  210.     catch(ex) {
  211.       // Combine the channel stack with this request stack
  212.       let error = Error(ex.message);
  213.       let chanStack = ex.stack.trim().split(/\n/).slice(1);
  214.       let requestStack = error.stack.split(/\n/).slice(1);
  215.  
  216.       // Strip out the args for the last 2 frames because they're usually HUGE!
  217.       for (let i = 0; i <= 1; i++)
  218.         requestStack[i] = requestStack[i].replace(/\(".*"\)@/, "(...)@");
  219.  
  220.       error.stack = chanStack.concat(requestStack).join("\n");
  221.       throw error;
  222.     }
  223.  
  224.     // Set some default values in-case there's no response header
  225.     let headers = {};
  226.     let status = 0;
  227.     let success = true;
  228.     try {
  229.       // Read out the response headers if available
  230.       channel.visitResponseHeaders({
  231.         visitHeader: function visitHeader(header, value) {
  232.           headers[header] = value;
  233.         }
  234.       });
  235.       status = channel.responseStatus;
  236.       success = channel.requestSucceeded;
  237.  
  238.       // Log the status of the request
  239.       let mesg = [action, success ? "success" : "fail", status,
  240.         channel.URI.spec].join(" ");
  241.       if (mesg.length > 200)
  242.         mesg = mesg.substr(0, 200) + "ΓǪ";
  243.       this._log.debug(mesg);
  244.       // Additionally give the full response body when Trace logging
  245.       if (this._log.level <= Log4Moz.Level.Trace)
  246.         this._log.trace(action + " body: " + this._data);
  247.  
  248.       // this is a server-side safety valve to allow slowing down clients without hurting performance
  249.       if (headers["X-Weave-Backoff"])
  250.         Observers.notify("weave:service:backoff:interval", parseInt(headers["X-Weave-Backoff"], 10))
  251.     }
  252.     // Got a response but no header; must be cached (use default values)
  253.     catch(ex) {
  254.       this._log.debug(action + " cached: " + status);
  255.     }
  256.  
  257.     let ret = new String(this._data);
  258.     ret.headers = headers;
  259.     ret.status = status;
  260.     ret.success = success;
  261.  
  262.     // Make a lazy getter to convert the json response into an object
  263.     Utils.lazy2(ret, "obj", function() JSON.parse(ret));
  264.  
  265.     return ret;
  266.   },
  267.  
  268.   // ** {{{ Resource.get }}} **
  269.   //
  270.   // Perform an asynchronous HTTP GET for this resource.
  271.   // onComplete will be called on completion of the request.
  272.   get: function Res_get() {
  273.     return this._request("GET");
  274.   },
  275.  
  276.   // ** {{{ Resource.get }}} **
  277.   //
  278.   // Perform a HTTP PUT for this resource.
  279.   put: function Res_put(data) {
  280.     return this._request("PUT", data);
  281.   },
  282.  
  283.   // ** {{{ Resource.post }}} **
  284.   //
  285.   // Perform a HTTP POST for this resource.
  286.   post: function Res_post(data) {
  287.     return this._request("POST", data);
  288.   },
  289.  
  290.   // ** {{{ Resource.delete }}} **
  291.   //
  292.   // Perform a HTTP DELETE for this resource.
  293.   delete: function Res_delete() {
  294.     return this._request("DELETE");
  295.   }
  296. };
  297.  
  298. // = ChannelListener =
  299. //
  300. // This object implements the {{{nsIStreamListener}}} interface
  301. // and is called as the network operation proceeds.
  302. function ChannelListener(onComplete, onProgress, logger) {
  303.   this._onComplete = onComplete;
  304.   this._onProgress = onProgress;
  305.   this._log = logger;
  306. }
  307. ChannelListener.prototype = {
  308.   onStartRequest: function Channel_onStartRequest(channel) {
  309.     channel.QueryInterface(Ci.nsIHttpChannel);
  310.     this._log.trace(channel.requestMethod + " " + channel.URI.spec);
  311.     this._data = '';
  312.   },
  313.  
  314.   onStopRequest: function Channel_onStopRequest(channel, context, status) {
  315.     if (this._data == '')
  316.       this._data = null;
  317.  
  318.     // Throw the failure code name (and stop execution)
  319.     if (!Components.isSuccessCode(status))
  320.       this._onComplete.throw(Error(Components.Exception("", status).name));
  321.  
  322.     this._onComplete(this._data);
  323.   },
  324.  
  325.   onDataAvailable: function Channel_onDataAvail(req, cb, stream, off, count) {
  326.     let siStream = Cc["@mozilla.org/scriptableinputstream;1"].
  327.       createInstance(Ci.nsIScriptableInputStream);
  328.     siStream.init(stream);
  329.  
  330.     this._data += siStream.read(count);
  331.     this._onProgress();
  332.   }
  333. };
  334.  
  335. // = badCertListener =
  336. //
  337. // We use this listener to ignore bad HTTPS
  338. // certificates and continue a request on a network
  339. // channel. Probably not a very smart thing to do,
  340. // but greatly simplifies debugging and is just very
  341. // convenient.
  342. function badCertListener() {
  343. }
  344. badCertListener.prototype = {
  345.   getInterface: function(aIID) {
  346.     return this.QueryInterface(aIID);
  347.   },
  348.  
  349.   QueryInterface: function(aIID) {
  350.     if (aIID.equals(Components.interfaces.nsIBadCertListener2) ||
  351.         aIID.equals(Components.interfaces.nsIInterfaceRequestor) ||
  352.         aIID.equals(Components.interfaces.nsISupports))
  353.       return this;
  354.  
  355.     throw Components.results.NS_ERROR_NO_INTERFACE;
  356.   },
  357.  
  358.   notifyCertProblem: function certProblem(socketInfo, sslStatus, targetHost) {
  359.     // Silently ignore?
  360.     let log = Log4Moz.repository.getLogger("Service.CertListener");
  361.     log.level =
  362.       Log4Moz.Level[Utils.prefs.getCharPref("log.logger.network.resources")];
  363.     log.debug("Invalid HTTPS certificate encountered, ignoring!");
  364.  
  365.     return true;
  366.   }
  367. };
  368.